home *** CD-ROM | disk | FTP | other *** search
/ Motor Sport Digital Archive Collection 1960s / Motor Sport Digital Archive Collection 1960s.iso / main.swf / scripts / mx / rpc / http / mxml / HTTPService.as
Encoding:
Text File  |  2008-05-21  |  4.3 KB  |  141 lines
  1. package mx.rpc.http.mxml
  2. {
  3.    import flash.events.ErrorEvent;
  4.    import mx.core.IMXMLObject;
  5.    import mx.core.mx_internal;
  6.    import mx.managers.CursorManager;
  7.    import mx.messaging.events.MessageEvent;
  8.    import mx.messaging.messages.AsyncMessage;
  9.    import mx.messaging.messages.IMessage;
  10.    import mx.rpc.AsyncDispatcher;
  11.    import mx.rpc.AsyncToken;
  12.    import mx.rpc.Fault;
  13.    import mx.rpc.events.AbstractEvent;
  14.    import mx.rpc.events.FaultEvent;
  15.    import mx.rpc.http.HTTPService;
  16.    import mx.rpc.mxml.Concurrency;
  17.    import mx.rpc.mxml.IMXMLSupport;
  18.    import mx.utils.Translator;
  19.    
  20.    use namespace mx_internal;
  21.    
  22.    public class HTTPService extends mx.rpc.http.HTTPService implements IMXMLSupport, IMXMLObject
  23.    {
  24.       private static const TRANSLATOR:Translator = Translator.getDefaultInstanceFor(mx.rpc.http.mxml.HTTPService);
  25.       
  26.       private var _concurrency:String;
  27.       
  28.       private var document:Object;
  29.       
  30.       private var _showBusyCursor:Boolean;
  31.       
  32.       private var id:String;
  33.       
  34.       public function HTTPService()
  35.       {
  36.          super();
  37.          showBusyCursor = false;
  38.          concurrency = Concurrency.MULTIPLE;
  39.       }
  40.       
  41.       override public function send(param1:Object = null) : AsyncToken
  42.       {
  43.          var _loc2_:AsyncToken = null;
  44.          var _loc3_:Fault = null;
  45.          var _loc4_:FaultEvent = null;
  46.          if(Concurrency.SINGLE == concurrency && Boolean(mx_internal::activeCalls.hasActiveCalls()))
  47.          {
  48.             _loc2_ = new AsyncToken(null);
  49.             _loc3_ = new Fault("ConcurrencyError",TRANSLATOR.textOf("pendingCallExists"));
  50.             _loc4_ = FaultEvent.createEvent(_loc3_,_loc2_);
  51.             new AsyncDispatcher(mx_internal::dispatchRpcEvent,[_loc4_],10);
  52.             return _loc2_;
  53.          }
  54.          return super.send(param1);
  55.       }
  56.       
  57.       public function get concurrency() : String
  58.       {
  59.          return _concurrency;
  60.       }
  61.       
  62.       public function set showBusyCursor(param1:Boolean) : void
  63.       {
  64.          _showBusyCursor = param1;
  65.       }
  66.       
  67.       public function get showBusyCursor() : Boolean
  68.       {
  69.          return _showBusyCursor;
  70.       }
  71.       
  72.       override mx_internal function preHandle(param1:MessageEvent) : AsyncToken
  73.       {
  74.          var _loc2_:AsyncToken = null;
  75.          if(showBusyCursor)
  76.          {
  77.             CursorManager.removeBusyCursor();
  78.          }
  79.          _loc2_ = super.mx_internal::preHandle(param1);
  80.          if("last" == concurrency && !mx_internal::activeCalls.wasLastCall(AsyncMessage(param1.message).correlationId))
  81.          {
  82.             return null;
  83.          }
  84.          return _loc2_;
  85.       }
  86.       
  87.       public function set concurrency(param1:String) : void
  88.       {
  89.          _concurrency = param1;
  90.       }
  91.       
  92.       override mx_internal function dispatchRpcEvent(param1:AbstractEvent) : void
  93.       {
  94.          var _loc2_:ErrorEvent = null;
  95.          param1.mx_internal::callTokenResponders();
  96.          if(!param1.isDefaultPrevented())
  97.          {
  98.             if(hasEventListener(param1.type))
  99.             {
  100.                dispatchEvent(param1);
  101.             }
  102.             else if(param1 is FaultEvent && (param1.token == null || !param1.token.hasResponder()))
  103.             {
  104.                if(!(Boolean(document) && Boolean(document.willTrigger(ErrorEvent.ERROR))))
  105.                {
  106.                   throw FaultEvent(param1).fault;
  107.                }
  108.                _loc2_ = new ErrorEvent(ErrorEvent.ERROR,true,true);
  109.                _loc2_.text = FaultEvent(param1).fault.faultString;
  110.                document.dispatchEvent(_loc2_);
  111.             }
  112.          }
  113.       }
  114.       
  115.       public function initialized(param1:Object, param2:String) : void
  116.       {
  117.          this.id = param2;
  118.          this.document = param1;
  119.       }
  120.       
  121.       override public function cancel() : void
  122.       {
  123.          if(showBusyCursor)
  124.          {
  125.             CursorManager.removeBusyCursor();
  126.          }
  127.          super.cancel();
  128.       }
  129.       
  130.       override mx_internal function invoke(param1:IMessage, param2:AsyncToken = null) : AsyncToken
  131.       {
  132.          if(showBusyCursor)
  133.          {
  134.             CursorManager.setBusyCursor();
  135.          }
  136.          return super.mx_internal::invoke(param1,param2);
  137.       }
  138.    }
  139. }
  140.  
  141.